• GC pressure — dominant cost. Allocations in Texpr.map_expr, TFunctions.follow, and Stdlib.List.map are the primary drivers. Profile with memtrace to locate top allocators; consider in-place traversal patterns.

@copilot This is usually fine in OCaml due to its generational GC, so you might be jumping to conclusions too quickly here. But memtrace sounds like a good plan, go ahead and do that!

• compare_val (3.3 %) — replace polymorphic (=)/compare with typed equality in hot typing/filter loops.

Indeed, please identify the places where this occurs.

• HXB zip decompression — storing entries as Stored (uncompressed) eliminates decompression cost entirely at the expense of archive size; alternatively, pre-decompress and cache per-module bytes after first access.

Agreed, let's store without compression.

• HxbWriter.write_type_instance — more aggressive type-reference deduplication (interned index) would shrink the archive and reduce write time.

I'm not sure what you mean here, please implement it so I can take a look!

• Domainslib.Multi_channel spin-wait — worker domains spin even for small jobs; add a module-count threshold before spawning domains.

I don't have a good solution for this because the Domainslib API only allows fixed domain pools (I think). Can you think of a better approach for managing domains?

Also, please be aware that your opam installation got stuck waiting for a y input, so make sure OPAMYES=1 is set when running it.

• GC pressure — dominant cost. Allocations in Texpr.map_expr, TFunctions.follow, and Stdlib.List.map are the primary drivers. Profile with memtrace to locate top allocators; consider i...

Addressed in 930c728:

GC / memtrace: memtrace doesn't work on OCaml 5 multicore (Gc.Memprof is unsupported). I used olly gc-stats (OCaml 5's runtime_events_tools) instead — GC overhead is 26% of CPU for eval, 43% for roundtrip. Full results in extra/PROFILING.md.

compare_val (3.1%): Identified via perf --symbol-filter. Called through both caml_compare (2%) and caml_equal (1%). Key sites:

• typeloadCheck.ml:187 — | a, b when a = b on field_kind
• typeloadCheck.ml:66,432 — MethDynamic / method kind comparisons
• fields.ml:41 — !(a.a_status) = Const on anon_status
• optimizerTexpr.ml:189 — a = b on constants
• nullSafety.ml — 26 Hashtbl.find/mem calls using polymorphic hash+equality

Full list in extra/PROFILING.md §2.

HXB compression: Changed to Stored (level 0). Read-phase get bytes dropped from 0.090s → 0.021s (4.3×). Archive grows 3.6 MB → 6.5 MB.

write_type_instance: Already deduplicated within expressions via write_texpr_type_instance which serializes to bytes then interns via StringPool. At 0.38% of perf time, the gains from further deduplication are minimal — left as-is with explanation in the guide.

Domainslib: The ManagedPool already supports lazy acquire/release. The issue is that Domainslib.Task.setup_pool creates a fixed set of domains that spin-wait. Two approaches: (1) use Domain.spawn directly for short parallel sections like HXB export, replacing ManagedPool for those paths, or (2) add a module-count threshold (e.g. >50 modules) before acquiring the pool. Approach (1) eliminates spin-wait entirely but loses automatic work-stealing; approach (2) is simpler. Documented in extra/PROFILING.md §5.

Also noted re: OPAMYES=1 — will use that going forward.

@copilot

• Please investigate the = situation because I don't think you're right about that. If the types are known at compile-time in OCaml, this should not lead to a polymorphic compare. Do some research and inspect the generated code to confirm.
• Could you suggest a framework for using from Domainslib to Domain.spawn? I don't really have a vision for how to control the number of domains and how to actually interact with such a setup. We don't want to constantly set up and tear down domains in such cases, so this has to be managed somehow.

@copilot

• Please investigate the = situation because I don't think you're right about that. If the types are known at compile-time in OCaml, this should not lead to a polymorphic...

Addressed in 7ed90ce and c8e7434.

= investigation: You were right — I verified by compiling test files with ocamlfind ocamlopt -S and inspecting the generated assembly. OCaml's native compiler specializes = in two cases:

1. Types where all constructors are constant (no args) — e.g. method_kind → emits cmpq
2. Comparing a variable against a literal constant constructor, even if the type has structured variants — e.g. anon_status = Const → emits cmpq $3, %rax

The sites I previously listed that are NOT polymorphic (corrected):

• typeloadCheck.ml:66 — m1 = MethDynamic: method_kind all-constant → direct compare
• typeloadCheck.ml:432 — mkind m1 = mkind m2: projects to int first → direct compare
• fields.ml:41 — !(a.a_status) = Const: literal constant ctor → direct compare

Still truly polymorphic (calls caml_equal):

• typeloadCheck.ml:187 — field_kind = field_kind (has Var of var_kind)
• optimizerTexpr.ml:189 — tconstant = tconstant (has TInt, TString, etc.)
• fields.ml:141,194 — e.eexpr = TConst TSuper (structured literal of huge variant type, but shallow)
• Path comparisons — string list * string
• nullSafety.ml — polymorphic Hashtbl with safety_subject keys (also contributes to the caml_hash 2.4%)

Full corrected analysis with assembly evidence in extra/PROFILING.md §2.

Domain.spawn framework: Added a concrete proposal in extra/PROFILING.md §5. The idea:

• Replace the persistent Domainslib pool with Domain.spawn + Domain.join for each parallel section
• All compiler parallel sections are simple data-parallel loops (array of modules/types) — no work-stealing or nested tasks needed
• parallel_for ~num_domains length f partitions work into contiguous chunks, spawns N-1 domains, runs one chunk on the calling domain, then joins all
• Add a min_parallel_items threshold (e.g. 32) to skip spawning for small arrays
• ManagedPool.t is replaced by a simple num_domains : int in the server context
• Zero idle CPU between parallel sections (no spin-wait)

@copilot I'm very curious about that parallel redesign. Go ahead and implement it, and make sure to measure the difference accurately. If this leads to the removal of Domainslib as a dependency, that'd be a bonus.

@copilot I'm very curious about that parallel redesign. Go ahead and implement it, and make sure to measure the difference accurately. If this leads to the removal of Domainslib as a dependency, that'...

Implemented in d9dd515. domainslib is fully removed from src/dune and haxe.opam.

Design: WorkerPool in src/context/parallel.ml spawns N-1 worker domains at pool creation. Workers block on Condition.wait between parallel_for calls (zero CPU). Work is distributed via contiguous chunk partitioning. A key detail: nested parallel_for calls (e.g. analyzer iterating types → iterating fields per type) are detected via an atomic busy flag and fall back to sequential, which prevents state corruption.

Benchmarks (4-core CI, median):

Within noise. The throughput is equivalent; the benefit is zero idle CPU (workers sleep instead of spin-waiting).